Python Django Testing: TestCase vs. TransactionTestCase

સોફ્ટવેર ડેવલપમેન્ટમાં ટેસ્ટિંગ એ એક નિર્ણાયક પાસું છે, જે સુનિશ્ચિત કરે છે કે તમારી એપ્લિકેશન અપેક્ષા મુજબ વર્તે છે અને સમય જતાં મજબૂત રહે છે. Django, એક લોકપ્રિય Python વેબ ફ્રેમવર્ક, અસરકારક પરીક્ષણો લખવામાં તમારી મદદ કરવા માટે શક્તિશાળી ટેસ્ટિંગ ફ્રેમવર્ક પ્રદાન કરે છે. આ બ્લોગ પોસ્ટ Django ના ટેસ્ટિંગ ફ્રેમવર્ક માં બે મૂળભૂત વર્ગો: TestCase અને TransactionTestCase માં ઊંડા ઉતરશે. અમે તેમના તફાવતો, ઉપયોગના કિસ્સાઓનું અન્વેષણ કરીશું અને તમારી પરીક્ષણ જરૂરિયાતો માટે યોગ્ય વર્ગ પસંદ કરવામાં મદદ કરવા માટે વ્યવહારુ ઉદાહરણો પ્રદાન કરીશું.

Django માં ટેસ્ટિંગ શા માટે મહત્વપૂર્ણ છે

TestCase અને TransactionTestCase ની વિશિષ્ટતાઓમાં ઊંડા ઉતરતા પહેલા, ચાલો ટૂંકમાં ચર્ચા કરીએ કે Django ડેવલપમેન્ટમાં ટેસ્ટિંગ શા માટે આટલું મહત્વપૂર્ણ છે:

• કોડ ગુણવત્તા સુનિશ્ચિત કરે છે: પરીક્ષણો તમને ડેવલપમેન્ટ પ્રક્રિયાના પ્રારંભમાં બગ્સ પકડવામાં મદદ કરે છે, તેને પ્રોડક્શનમાં પહોંચતા અટકાવે છે.
• રિફેક્ટરિંગને સુવિધા આપે છે: વ્યાપક પરીક્ષણ સ્યુટ સાથે, તમે તમારા કોડને વિશ્વાસપૂર્વક રિફેક્ટર કરી શકો છો, એ જાણીને કે જો તમે કોઈ રિગ્રેશન દાખલ કરો છો તો પરીક્ષણો તમને ચેતવણી આપશે.
• સહયોગ સુધારે છે: સારી રીતે લખાયેલા પરીક્ષણો તમારા કોડ માટે દસ્તાવેજીકરણ તરીકે કાર્ય કરે છે, અન્ય ડેવલપર્સ માટે સમજવું અને યોગદાન આપવાનું સરળ બનાવે છે.
• ટેસ્ટ-ડ્રિવન ડેવલપમેન્ટ (TDD) ને સપોર્ટ કરે છે: TDD એ એક ડેવલપમેન્ટ અભિગમ છે જ્યાં તમે વાસ્તવિક કોડ લખતા પહેલા પરીક્ષણો લખો છો. આ તમને શરૂઆતથી તમારી એપ્લિકેશનના ઇચ્છિત વર્તન વિશે વિચારવા દબાણ કરે છે, જે સ્વચ્છ અને વધુ જાળવણી યોગ્ય કોડ તરફ દોરી જાય છે.

Django નું ટેસ્ટિંગ ફ્રેમવર્ક: એક ઝડપી ઝાંખી

Django નું ટેસ્ટિંગ ફ્રેમવર્ક Python ના બિલ્ટ-ઇન unittest મોડ્યુલ પર બનેલું છે. તે Django એપ્લિકેશન્સનું પરીક્ષણ કરવાનું સરળ બનાવતી ઘણી સુવિધાઓ પ્રદાન કરે છે, જેમાં નીચેનાનો સમાવેશ થાય છે:

• ટેસ્ટ ડિસ્કવરી: Django આપમેળે તમારા પ્રોજેક્ટમાં પરીક્ષણો શોધી કાઢે છે અને ચલાવે છે.
• ટેસ્ટ રનર: Django એક ટેસ્ટ રનર પ્રદાન કરે છે જે તમારા પરીક્ષણો ચલાવે છે અને પરિણામોની જાણ કરે છે.
• એસર્શન મેથડ્સ: Django એસર્શન મેથડ્સનો સમૂહ પ્રદાન કરે છે જેનો ઉપયોગ તમે તમારા કોડના અપેક્ષિત વર્તનની ચકાસણી કરવા માટે કરી શકો છો.
• ક્લાયન્ટ: Django નો ટેસ્ટ ક્લાયન્ટ તમને તમારી એપ્લિકેશન સાથે વપરાશકર્તા ક્રિયાપ્રતિક્રિયાઓનું અનુકરણ કરવા દે છે, જેમ કે ફોર્મ સબમિટ કરવા અથવા API વિનંતીઓ કરવી.
• TestCase અને TransactionTestCase: આ Django માં પરીક્ષણો લખવા માટેના બે મૂળભૂત વર્ગો છે, જેની અમે વિગતવાર તપાસ કરીશું.

TestCase: ઝડપી અને કાર્યક્ષમ યુનિટ ટેસ્ટિંગ

TestCase એ Django માં યુનિટ ટેસ્ટ લખવા માટેનો પ્રાથમિક વર્ગ છે. તે દરેક ટેસ્ટ કેસ માટે સ્વચ્છ ડેટાબેઝ વાતાવરણ પ્રદાન કરે છે, ખાતરી કરે છે કે પરીક્ષણો અલગ છે અને એકબીજાને દખલ કરતા નથી.

TestCase કેવી રીતે કાર્ય કરે છે

જ્યારે તમે TestCase નો ઉપયોગ કરો છો, ત્યારે Django દરેક ટેસ્ટ મેથડ માટે નીચેના પગલાંઓ કરે છે:

1. ટેસ્ટ ડેટાબેઝ બનાવે છે: Django દરેક ટેસ્ટ રન માટે એક અલગ ટેસ્ટ ડેટાબેઝ બનાવે છે.
2. ડેટાબેઝ ફ્લશ કરે છે: દરેક ટેસ્ટ મેથડ પહેલાં, Django ટેસ્ટ ડેટાબેઝને ફ્લશ કરે છે, હાલનો તમામ ડેટા દૂર કરે છે.
3. ટેસ્ટ મેથડ ચલાવે છે: Django તમે વ્યાખ્યાયિત કરેલી ટેસ્ટ મેથડ ચલાવે છે.
4. ટ્રાન્ઝેક્શન રોલબેક કરે છે: દરેક ટેસ્ટ મેથડ પછી, Django ટ્રાન્ઝેક્શનને રોલબેક કરે છે, પરીક્ષણ દરમિયાન ડેટાબેઝમાં કરવામાં આવેલા કોઈપણ ફેરફારોને અસરકારક રીતે પૂર્વવત્ કરે છે.

આ અભિગમ સુનિશ્ચિત કરે છે કે દરેક ટેસ્ટ મેથડ સ્વચ્છ સ્લેટથી શરૂ થાય છે અને ડેટાબેઝમાં કરવામાં આવેલા કોઈપણ ફેરફારો આપમેળે પૂર્વવત્ થઈ જાય છે. આ TestCase ને યુનિટ ટેસ્ટિંગ માટે આદર્શ બનાવે છે, જ્યાં તમે તમારી એપ્લિકેશનના વ્યક્તિગત ઘટકોનું અલગથી પરીક્ષણ કરવા માંગો છો.

ઉદાહરણ: એક સરળ મોડેલનું પરીક્ષણ

ચાલો TestCase નો ઉપયોગ કરીને Django મોડેલનું પરીક્ષણ કરવાનું એક સરળ ઉદાહરણ ધ્યાનમાં લઈએ:

from django.test import TestCase
from .models import Product

class ProductModelTest(TestCase):
 def test_product_creation(self):
 product = Product.objects.create(name="Test Product", price=10.00)
 self.assertEqual(product.name, "Test Product")
 self.assertEqual(product.price, 10.00)
 self.assertTrue(isinstance(product, Product))

આ ઉદાહરણમાં, અમે Product મોડેલ ઇન્સ્ટન્સ બનાવવાનું પરીક્ષણ કરી રહ્યા છીએ. test_product_creation મેથડ એક નવું ઉત્પાદન બનાવે છે અને પછી ઉત્પાદનના એટ્રિબ્યુટ્સ યોગ્ય રીતે સેટ થયા છે તેની ચકાસણી કરવા માટે એસર્શન મેથડ્સનો ઉપયોગ કરે છે.

TestCase નો ઉપયોગ ક્યારે કરવો

TestCase સામાન્ય રીતે મોટાભાગના Django પરીક્ષણ દૃશ્યો માટે પસંદગીનો વિકલ્પ છે. તે ઝડપી, કાર્યક્ષમ છે અને દરેક પરીક્ષણ માટે સ્વચ્છ ડેટાબેઝ વાતાવરણ પ્રદાન કરે છે. TestCase નો ઉપયોગ કરો જ્યારે:

• તમે તમારી એપ્લિકેશનના વ્યક્તિગત મોડેલ્સ, વ્યુઝ અથવા અન્ય ઘટકોનું પરીક્ષણ કરી રહ્યાં છો.
• તમે ખાતરી કરવા માંગો છો કે તમારા પરીક્ષણો અલગ છે અને એકબીજાને દખલ કરતા નથી.
• તમારે બહુવિધ ટ્રાન્ઝેક્શનમાં ફેલાયેલી જટિલ ડેટાબેઝ ક્રિયાપ્રતિક્રિયાઓનું પરીક્ષણ કરવાની જરૂર નથી.

TransactionTestCase: જટિલ ડેટાબેઝ ક્રિયાપ્રતિક્રિયાઓનું પરીક્ષણ

TransactionTestCase એ Django માં પરીક્ષણો લખવા માટેનો બીજો વર્ગ છે, પરંતુ તે ડેટાબેઝ ટ્રાન્ઝેક્શનને કેવી રીતે હેન્ડલ કરે છે તેમાં TestCase થી અલગ પડે છે. દરેક ટેસ્ટ મેથડ પછી ટ્રાન્ઝેક્શનને રોલબેક કરવાને બદલે, TransactionTestCase ટ્રાન્ઝેક્શનને કમિટ કરે છે. આ તેને બહુવિધ ટ્રાન્ઝેક્શનમાં ફેલાયેલી જટિલ ડેટાબેઝ ક્રિયાપ્રતિક્રિયાઓનું પરીક્ષણ કરવા માટે યોગ્ય બનાવે છે, જેમ કે સિગ્નલ અથવા એટોમિક ટ્રાન્ઝેક્શન સામેલ હોય.

TransactionTestCase કેવી રીતે કાર્ય કરે છે

જ્યારે તમે TransactionTestCase નો ઉપયોગ કરો છો, ત્યારે Django દરેક ટેસ્ટ કેસ માટે નીચેના પગલાંઓ કરે છે:

1. ટેસ્ટ ડેટાબેઝ બનાવે છે: Django દરેક ટેસ્ટ રન માટે એક અલગ ટેસ્ટ ડેટાબેઝ બનાવે છે.
2. ડેટાબેઝ ફ્લશ કરતું નથી: TransactionTestCase દરેક પરીક્ષણ પહેલાં ડેટાબેઝને આપમેળે ફ્લશ કરતું નથી. તે અપેક્ષા રાખે છે કે દરેક પરીક્ષણ ચલાવતા પહેલા ડેટાબેઝ સુસંગત સ્થિતિમાં હોય.
3. ટેસ્ટ મેથડ ચલાવે છે: Django તમે વ્યાખ્યાયિત કરેલી ટેસ્ટ મેથડ ચલાવે છે.
4. ટ્રાન્ઝેક્શન કમિટ કરે છે: દરેક ટેસ્ટ મેથડ પછી, Django ટ્રાન્ઝેક્શનને કમિટ કરે છે, જેનાથી ફેરફારો ટેસ્ટ ડેટાબેઝમાં કાયમી બને છે.
5. ટેબલ ટ્રંકેટ કરે છે: TransactionTestCase માંના બધા પરીક્ષણોના અંતે, ડેટા સાફ કરવા માટે ટેબલ ટ્રંકેટ કરવામાં આવે છે.

કારણ કે TransactionTestCase દરેક ટેસ્ટ મેથડ પછી ટ્રાન્ઝેક્શનને કમિટ કરે છે, તે સુનિશ્ચિત કરવું આવશ્યક છે કે તમારા પરીક્ષણો ડેટાબેઝને અસંગત સ્થિતિમાં છોડતા નથી. તમે સબસીક્વન્ટ પરીક્ષણોમાં દખલ ટાળવા માટે પરીક્ષણ દરમિયાન બનાવેલ કોઈપણ ડેટાને મેન્યુઅલી સાફ કરવાની જરૂર પડી શકે છે.

ઉદાહરણ: સિગ્નલનું પરીક્ષણ

ચાલો TransactionTestCase નો ઉપયોગ કરીને Django સિગ્નલનું પરીક્ષણ કરવાનું ઉદાહરણ ધ્યાનમાં લઈએ:

from django.test import TransactionTestCase
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Product, ProductLog

@receiver(post_save, sender=Product)
def create_product_log(sender, instance, created, **kwargs):
 if created:
 ProductLog.objects.create(product=instance, action="Created")

class ProductSignalTest(TransactionTestCase):
def test_product_creation_signal(self):
 product = Product.objects.create(name="Test Product", price=10.00)
 self.assertEqual(ProductLog.objects.count(), 1)
 self.assertEqual(ProductLog.objects.first().product, product)
 self.assertEqual(ProductLog.objects.first().action, "Created")

આ ઉદાહરણમાં, અમે એક સિગ્નલનું પરીક્ષણ કરી રહ્યા છીએ જે નવો Product ઇન્સ્ટન્સ બનાવવામાં આવે ત્યારે ProductLog ઇન્સ્ટન્સ બનાવે છે. test_product_creation_signal મેથડ એક નવું ઉત્પાદન બનાવે છે અને પછી ચકાસે છે કે સંબંધિત પ્રોડક્ટ લોગ એન્ટ્રી બનાવવામાં આવી છે.

TransactionTestCase નો ઉપયોગ ક્યારે કરવો

TransactionTestCase સામાન્ય રીતે વિશિષ્ટ દૃશ્યોમાં ઉપયોગ થાય છે જ્યાં તમારે બહુવિધ ટ્રાન્ઝેક્શનમાં ફેલાયેલી જટિલ ડેટાબેઝ ક્રિયાપ્રતિક્રિયાઓનું પરીક્ષણ કરવાની જરૂર હોય છે. TransactionTestCase નો ઉપયોગ કરવાનું વિચારો જ્યારે:

• તમે ડેટાબેઝ ઓપરેશન્સ દ્વારા ટ્રિગર થયેલા સિગ્નલનું પરીક્ષણ કરી રહ્યાં છો.
• તમે એટોમિક ટ્રાન્ઝેક્શનનું પરીક્ષણ કરી રહ્યાં છો જેમાં બહુવિધ ડેટાબેઝ ઓપરેશન્સ સામેલ છે.
• તમારે સંબંધિત ઓપરેશન્સની શ્રેણી પછી ડેટાબેઝની સ્થિતિની ચકાસણી કરવાની જરૂર છે.
• તમે એવા કોડનો ઉપયોગ કરી રહ્યાં છો જે પરીક્ષણો વચ્ચે ટકી રહેવા માટે ઓટો-ઇન્ક્રીમેન્ટિંગ ID પર આધાર રાખે છે (જોકે આ સામાન્ય રીતે ખરાબ પ્રેક્ટિસ માનવામાં આવે છે).

TransactionTestCase નો ઉપયોગ કરતી વખતે ધ્યાનમાં રાખવા જેવી મહત્વપૂર્ણ બાબતો

કારણ કે TransactionTestCase ટ્રાન્ઝેક્શનને કમિટ કરે છે, નીચેની બાબતોથી વાકેફ રહેવું મહત્વપૂર્ણ છે:

• ડેટાબેઝ સફાઈ: સબસીક્વન્ટ પરીક્ષણોમાં દખલ ટાળવા માટે પરીક્ષણ દરમિયાન બનાવેલ કોઈપણ ડેટાને મેન્યુઅલી સાફ કરવાની જરૂર પડી શકે છે. પરીક્ષણ ડેટાનું સંચાલન કરવા માટે setUp અને tearDown પદ્ધતિઓનો ઉપયોગ કરવાનું વિચારો.
• ટેસ્ટ આઇસોલેશન: TransactionTestCase TestCase જેવી ટેસ્ટ આઇસોલેશનનું સમાન સ્તર પ્રદાન કરતું નથી. પરીક્ષણો વચ્ચે સંભવિત ક્રિયાપ્રતિક્રિયાઓથી વાકેફ રહો અને ખાતરી કરો કે તમારા પરીક્ષણો પાછલા પરીક્ષણોમાંથી ડેટાબેઝની સ્થિતિ પર આધાર રાખતા નથી.
• પ્રદર્શન: TransactionTestCase TestCase કરતાં ધીમું હોઈ શકે છે કારણ કે તેમાં ટ્રાન્ઝેક્શન કમિટ કરવાનો સમાવેશ થાય છે. તેનો સમજદારીપૂર્વક ઉપયોગ કરો અને ફક્ત ત્યારે જ જ્યારે જરૂરી હોય.

Django ટેસ્ટિંગ માટે શ્રેષ્ઠ પ્રેક્ટિસ

Django માં પરીક્ષણો લખતી વખતે ધ્યાનમાં રાખવા જેવી કેટલીક શ્રેષ્ઠ પ્રેક્ટિસ અહીં છે:

• સ્પષ્ટ અને સંક્ષિપ્ત પરીક્ષણો લખો: પરીક્ષણો સમજવા અને જાળવવા માટે સરળ હોવા જોઈએ. ટેસ્ટ મેથડ્સ અને એસર્શન્સ માટે વર્ણનાત્મક નામોનો ઉપયોગ કરો.
• એક સમયે એક વસ્તુનું પરીક્ષણ કરો: દરેક ટેસ્ટ મેથડ તમારા કોડના એક જ પાસાનું પરીક્ષણ કરવા પર ધ્યાન કેન્દ્રિત કરવું જોઈએ. આ પરીક્ષણ નિષ્ફળ જાય ત્યારે નિષ્ફળતાના સ્ત્રોતને ઓળખવાનું સરળ બનાવે છે.
• અર્થપૂર્ણ એસર્શન્સનો ઉપયોગ કરો: એવી એસર્શન મેથડ્સનો ઉપયોગ કરો જે તમારા કોડના અપેક્ષિત વર્તનને સ્પષ્ટપણે વ્યક્ત કરે છે. Django વિવિધ દૃશ્યો માટે એસર્શન મેથડ્સનો સમૃદ્ધ સમૂહ પ્રદાન કરે છે.
• Arrange-Act-Assert પેટર્નને અનુસરો: તમારા પરીક્ષણોને Arrange-Act-Assert પેટર્ન અનુસાર ગોઠવો: ટેસ્ટ ડેટા ગોઠવો, પરીક્ષણ હેઠળના કોડ પર કાર્ય કરો, અને અપેક્ષિત પરિણામની પુષ્ટિ કરો.
• તમારા પરીક્ષણોને ઝડપી રાખો: ધીમા પરીક્ષણો વિકાસકર્તાઓને તેમને વારંવાર ચલાવવાથી નિરાશ કરી શકે છે. એક્ઝેક્યુશન સમય ઘટાડવા માટે તમારા પરીક્ષણોને ઓપ્ટિમાઇઝ કરો.
• ટેસ્ટ ડેટા માટે ફિક્સરનો ઉપયોગ કરો: ફિક્સર તમારા ટેસ્ટ ડેટાબેઝમાં પ્રારંભિક ડેટા લોડ કરવાની એક અનુકૂળ રીત છે. સુસંગત અને પુનઃઉપયોગી ટેસ્ટ ડેટા બનાવવા માટે ફિક્સરનો ઉપયોગ કરો. ID ને હાર્ડકોડ કરવાનું ટાળવા માટે ફિક્સરમાં નેચરલ કીઝનો ઉપયોગ કરવાનું વિચારો.
• pytest જેવી ટેસ્ટિંગ લાઇબ્રેરીનો ઉપયોગ કરવાનું વિચારો: જ્યારે Django નું બિલ્ટ-ઇન ટેસ્ટિંગ ફ્રેમવર્ક શક્તિશાળી છે, ત્યારે pytest જેવી લાઇબ્રેરીઓ વધારાની સુવિધાઓ અને સુગમતા પ્રદાન કરી શકે છે.
• ઉચ્ચ ટેસ્ટ કવરેજ માટે પ્રયત્ન કરો: ખાતરી કરો કે તમારો કોડ સંપૂર્ણ રીતે પરીક્ષણ થયેલ છે તે સુનિશ્ચિત કરવા માટે ઉચ્ચ ટેસ્ટ કવરેજનું લક્ષ્ય રાખો. તમારા ટેસ્ટ કવરેજને માપવા અને વધુ પરીક્ષણની જરૂર હોય તેવા વિસ્તારોને ઓળખવા માટે કવરેજ ટૂલ્સનો ઉપયોગ કરો.
• તમારા પરીક્ષણોને તમારા CI/CD પાઇપલાઇનમાં એકીકૃત કરો: તમારા સતત ઇન્ટિગ્રેશન અને સતત ડિપ્લોયમેન્ટ (CI/CD) પાઇપલાઇનના ભાગ રૂપે તમારા પરીક્ષણોને આપમેળે ચલાવો. આ સુનિશ્ચિત કરે છે કે ડેવલપમેન્ટ પ્રક્રિયાના પ્રારંભમાં કોઈપણ રિગ્રેશન પકડાઈ જાય છે.
• વાસ્તવિક-વિશ્વના દૃશ્યોને પ્રતિબિંબિત કરતા પરીક્ષણો લખો: તમારી એપ્લિકેશનનું પરીક્ષણ એવા રસ્તાઓ પર કરો જે વપરાશકર્તાઓ તેની સાથે કેવી રીતે વાસ્તવિક રીતે ક્રિયાપ્રતિક્રિયા કરશે તેનું અનુકરણ કરે છે. આ તમને એવા બગ્સને ઉજાગર કરવામાં મદદ કરશે જે સરળ યુનિટ પરીક્ષણોમાં સ્પષ્ટ ન હોય. ઉદાહરણ તરીકે, ફોર્મનું પરીક્ષણ કરતી વખતે આંતરરાષ્ટ્રીય સરનામાં અને ફોન નંબરોના વિવિધતાઓને ધ્યાનમાં લો.

આંતરરાષ્ટ્રીયકરણ (i18n) અને ટેસ્ટિંગ

જ્યારે વૈશ્વિક પ્રેક્ષકો માટે Django એપ્લિકેશન્સ વિકસાવવામાં આવે છે, ત્યારે આંતરરાષ્ટ્રીયકરણ (i18n) અને સ્થાનિકીકરણ (l10n) ધ્યાનમાં લેવું નિર્ણાયક છે. ખાતરી કરો કે તમારા પરીક્ષણો વિવિધ ભાષાઓ, તારીખ ફોર્મેટ્સ અને ચલણ ચિહ્નોને આવરી લે છે. અહીં કેટલીક ટીપ્સ આપી છે:

• વિવિધ ભાષા સેટિંગ્સ સાથે પરીક્ષણ કરો: તમારી એપ્લિકેશનનું વિવિધ ભાષા સેટિંગ્સ સાથે પરીક્ષણ કરવા માટે Django ના override_settings ડેકોરેટરનો ઉપયોગ કરો.
• તમારા પરીક્ષણોમાં સ્થાનિક ડેટાનો ઉપયોગ કરો: ખાતરી કરવા માટે કે તમારી એપ્લિકેશન વિવિધ તારીખ ફોર્મેટ્સ, ચલણ ચિહ્નો અને અન્ય લોકેલ-વિશિષ્ટ ડેટાને યોગ્ય રીતે હેન્ડલ કરે છે તે સુનિશ્ચિત કરવા માટે તમારા ટેસ્ટ ફિક્સર અને ટેસ્ટ પદ્ધતિઓમાં સ્થાનિક ડેટાનો ઉપયોગ કરો.
• તમારા અનુવાદ સ્ટ્રિંગ્સનું પરીક્ષણ કરો: ચકાસો કે તમારી અનુવાદ સ્ટ્રિંગ્સ યોગ્ય રીતે અનુવાદિત થયેલ છે અને તે વિવિધ ભાષાઓમાં યોગ્ય રીતે રેન્ડર થાય છે.
• localize ટેમ્પલેટ ટૅગનો ઉપયોગ કરો: તમારા ટેમ્પલેટ્સમાં, વપરાશકર્તાના વર્તમાન લોકેલ અનુસાર તારીખો, સંખ્યાઓ અને અન્ય લોકેલ-વિશિષ્ટ ડેટાને ફોર્મેટ કરવા માટે localize ટેમ્પલેટ ટૅગનો ઉપયોગ કરો.

ઉદાહરણ: વિવિધ ભાષા સેટિંગ્સ સાથે પરીક્ષણ

from django.test import TestCase
from django.utils import translation
from django.conf import settings

class InternationalizationTest(TestCase):

 def test_localized_date_format(self):
 original_language = translation.get_language()
 try:
 translation.activate('de') # Activate German language
 with self.settings(LANGUAGE_CODE='de'): # Set the language in settings
 from django.utils import formats
 from datetime import date
 d = date(2024, 1, 20)
 formatted_date = formats.date_format(d, 'SHORT_DATE_FORMAT')
 self.assertEqual(formatted_date, '20.01.2024')
 finally:
 translation.activate(original_language) # Restore original language

આ ઉદાહરણ Django ના translation અને formats મોડ્યુલ્સનો ઉપયોગ કરીને વિવિધ ભાષા સેટિંગ્સ સાથે તારીખ ફોર્મેટિંગનું પરીક્ષણ કેવી રીતે કરવું તે દર્શાવે છે.

નિષ્કર્ષ

Django માં અસરકારક અને વિશ્વસનીય પરીક્ષણો લખવા માટે TestCase અને TransactionTestCase વચ્ચેના તફાવતોને સમજવું આવશ્યક છે. TestCase સામાન્ય રીતે મોટાભાગના પરીક્ષણ દૃશ્યો માટે પસંદગીનો વિકલ્પ છે, જે તમારી એપ્લિકેશનના વ્યક્તિગત ઘટકોનું અલગથી પરીક્ષણ કરવાની ઝડપી અને કાર્યક્ષમ રીત પ્રદાન કરે છે. TransactionTestCase સિગ્નલ અથવા એટોમિક ટ્રાન્ઝેક્શન જેવી બહુવિધ ટ્રાન્ઝેક્શનમાં ફેલાયેલી જટિલ ડેટાબેઝ ક્રિયાપ્રતિક્રિયાઓનું પરીક્ષણ કરવા માટે ઉપયોગી છે. શ્રેષ્ઠ પ્રેક્ટિસને અનુસરીને અને આંતરરાષ્ટ્રીયકરણ પાસાઓને ધ્યાનમાં લઈને, તમે એક મજબૂત પરીક્ષણ સ્યુટ બનાવી શકો છો જે તમારી Django એપ્લિકેશન્સની ગુણવત્તા અને જાળવણીક્ષમતા સુનિશ્ચિત કરે છે.

વધુ શીખવા માટે

• Django Testing Documentation
• Python unittest Documentation
• pytest Documentation